// 位置获取和管理工具

/**
 * 检查位置权限
 * @returns {Promise} 包含权限状态的Promise
 */
export const checkLocationPermission = () => {
    return new Promise((resolve, reject) => {
        uni.getSetting({
            success: (res) => {
                resolve(res.authSetting['scope.userLocation'] === true);
            },
            fail: (err) => {
                console.error('获取设置失败:', err);
                reject(err);
            }
        });
    });
};

/**
 * 请求位置权限
 * @returns {Promise} 包含授权结果的Promise
 */
export const requestLocationPermission = () => {
    return new Promise((resolve, reject) => {
        uni.authorize({
            scope: 'scope.userLocation',
            success: () => {
                resolve(true);
            },
            fail: (err) => {
                console.error('授权失败:', err);
                reject(err);
            }
        });
    });
};

/**
 * 获取当前位置
 * @returns {Promise} 包含位置信息的Promise
 */
export const getCurrentLocation = () => {
    return new Promise((resolve, reject) => {
        uni.getLocation({
            type: 'gcj02',
            success: (res) => {
                console.log('位置获取成功:', res);

                // 保存到本地存储
                try {
                    uni.setStorageSync('userLocation', {
                        longitude: res.longitude,
                        latitude: res.latitude,
                        timestamp: Date.now()
                    });
                    uni.setStorageSync('hasLocation', true);
                } catch (e) {
                    console.error('保存位置信息失败:', e);
                }

                resolve(res);
            },
            fail: (err) => {
                console.error('位置获取失败:', err);

                // 处理特定的权限错误
                if (err.errMsg && err.errMsg.includes('requiredPrivateInfos')) {
                    reject(new Error('需要在app.json中配置位置权限声明'));
                } else if (err.errMsg && err.errMsg.includes('auth deny')) {
                    reject(new Error('用户拒绝了位置权限'));
                } else if (err.errMsg && err.errMsg.includes('authorize:fail')) {
                    reject(new Error('位置权限未授权'));
                } else {
                    reject(err);
                }
            }
        });
    });
};

/**
 * 打开设置页面
 * @returns {Promise} 包含设置结果的Promise
 */
export const openLocationSettings = () => {
    return new Promise((resolve) => {
        uni.openSetting({
            success: (res) => {
                resolve(res.authSetting['scope.userLocation'] === true);
            },
            fail: () => {
                resolve(false);
            }
        });
    });
};

/**
 * 完整位置获取流程
 * @returns {Promise} 包含位置信息的Promise
 */
export const getLocationWithPermission = async () => {
    try {
        // 先检查是否有缓存的位置
        const cachedLocation = uni.getStorageSync('userLocation');
        if (cachedLocation && (Date.now() - cachedLocation.timestamp) < 30 * 60 * 1000) {
            console.log('使用缓存的位置信息');
            return {
                longitude: cachedLocation.longitude,
                latitude: cachedLocation.latitude,
                fromCache: true
            };
        }
        
        // 检查是否有权限
        const hasPermission = await checkLocationPermission();
        
        if (hasPermission) {
            // 已有权限，直接获取位置
            return await getCurrentLocation();
        } else {
            // 请求权限
            await requestLocationPermission();
            return await getCurrentLocation();
        }
    } catch (error) {
        console.error('位置获取流程错误:', error);
        
        // 尝试打开设置页面
        if (error.errMsg && error.errMsg.includes('authorize:fail')) {
            const showSettings = await new Promise((resolve) => {
                uni.showModal({
                    title: '需要位置权限',
                    content: '为了为您推荐附近的教师，需要获取您的位置权限。是否去设置？',
                    success: (res) => {
                        resolve(res.confirm);
                    }
                });
            });
            
            if (showSettings) {
                const settingsResult = await openLocationSettings();
                if (settingsResult) {
                    return await getCurrentLocation();
                }
            }
        }
        
        throw error;
    }
};

export default {
    checkLocationPermission,
    requestLocationPermission,
    getCurrentLocation,
    openLocationSettings,
    getLocationWithPermission
}; 